In a communication network, it is common for an application server to manage a service that is provided to a user. The service itself is often a combination of pieces of software that provide a certain functionality for the user. The functionality is usually pre-defined by the developer (e.g., network operator) of the service and remains static unless the implementation of the service is changed. However, it is common to want to change the implementation of the service after the developer has pre-defined the service. One way to change the service is to use aspect oriented programming (AOP) which is a technique that allows the implementation of the service to be changed by adding functionality to the original service without directly modifying the target application code of the original service. AOP is well known to those skilled in the art but a brief description of the basics of AOP is provided below before explaining how a feature thereof can be improved which would make it easier to add functionality to a service.
AOP is a technique in software design that helps one to implement multiple functions into an application. Often the code of these functions is heavily tangled in the sense that code pieces dedicated to one function needs to be allocated at multiple places within the code of the other functions. This property is referred to as cross-cutting of concerns. However, a clean and modular implementation of these multiple functions by separating them into dedicated and encapsulated units is frequently not possible or extremely difficult.
AOP allows the code for the application to be kept separate from the code of the cross-cutting functionality. This separate implementation is called an aspect. Applying an aspect to an application in order to add the function that is implemented by the aspect is referred to as weaving. The weaving of an aspect can be done offline and thus prior to the execution of an application. This usually means, that weaving generates a new application from the target application, by injecting the aspect code into those code locations that are referred to by the point-cuts. In addition, the weaving of an aspect can also be done online, which means that the execution of an application is monitored and once it reaches a condition that is specified by the point-cut, the aspect is executed before continuing the execution of the application.
Weaving is steered by point-cuts, which is a generic definition of those locations known as join-points within an application, where the aspect code should be added. For example, the point-cut might specify to execute the aspect at every call of a certain method. The point-cuts are based on conditions that capture points within the source code of the target application or it refers to events with the application execution. In principle this technique could allow the automatic application of a certain functionality automatically even without analyzing an application. For example, if a new application is deployed within a service execution environment, the aspects that exist within this environment could be automatically applied to this new target application. This is in particular interesting in a telecommunication context, when using services from third party service providers. These third party services might not support all the functions required by the network operator. For example, activity logging or charging might not be implemented by the third party services. Thus, with the help of AOP these features can be automatically added to the target application. The devices and methods which can accomplish this is the subject of the present invention.